home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
9-Digit Zip Code Directory
/
9-Digit Zip Code Directory (American Business Information) (ABIZIP-12).ISO
/
z4src.zip
/
Z4.H
< prev
next >
Wrap
C/C++ Source or Header
|
1995-09-14
|
55KB
|
1,725 lines
#ifndef _Z4_H_
#define _Z4_H_
//----------------------------------------------------------------------------
// MODULE DESCRIPTION
//
// Module: z4.h
// Title: ZIP+4 Engine
// Notice: John M. Weeder
// Copyright (c) 1993. All rights reserved.
// This module contains proprietary information and should be
// treated as confidential.
//
//----------------------------------------------------------------------------
// MAINTENANCE HISTORY
//
// $Workfile$
// $Revision$
// $Author$
// $Date$
// $Log$
//
//----------------------------------------------------------------------------
// MODULE NARRATIVE
//
//
// This is the main header file for the ZIP+4 engine.
//
// The code in this module is mixed C and C++. All procedures used by
// the build procedure should be C only!
//
// This module is portable to:
// DOS 3.X+
// MS Windows 3.X+
// OS/2 2.X+
// OS/2 2.0 PM
// SCO UNIX.
//
// The following compilers are supported:
// MSC 6.0A
// MSC/C++ 7.0
// Borland C++ 3.1 for DOS
// Borland C++ 1.0 for OS/2 2.X
// SCO UNIX cc
//
//----------------------------------------------------------------------------
#include <base.h>
#if COMPILE_CPP
# include <class.hpp>
#endif
#include <dio.h>
#include <data.h>
#include <compress.h>
//----------------------------------------------------------------------------
// These are special flags controlling the compile.
//----------------------------------------------------------------------------
#define USE_STATES_ONLY (1) // Only US states?
//----------------------------------------------------------------------------
// Fields Sizes
//----------------------------------------------------------------------------
//
// These are field length definitions. The field lengths do not include
// null terminators
//
#define MAX_ADDR_LINE (50) // Address line length
#define MAX_ADDR (160) // Complete address line
#define MAX_INPUT_ADDR (50) // Input address line
#define MAX_INPUT_CITY (50) // Input city
#define MAX_INPUT_STATE (2) // Input state
#define MAX_INPUT_ZIP (15) // Input ZIP
#define MAX_CITY (28) // City name
#define MAX_CITY_ABBREV (13) // City abbreviation
#define MAX_STATE (2) // State name
#define MAX_ZIP5 (5) // ZIP5
#define MAX_ZIP5_BCD (3) // BCD encoded ZIP4
#define MAX_ZIP4 (9) // ZIP+4
#define MAX_ZIP4_BCD (5) // BCD encoded ZIP+4
#define MAX_ADDON (4) // Addon
#define MAX_ADDON_BCD (2) // Addon BCD
#define MAX_SEC_NAME (40) // Secondary name chgd fm 25 to 40
#define MAX_PRI_NO (10) // Primary number
#define MAX_PRI_NAME (28) // Primary name chgd fm 22 to 28
#define MAX_SUFFIX (4) // Suffix
#define MAX_SEC_NO (8) // Secondary number chgd fm 6 to 8
// Maximum of primary or secondary range
#define MAX_RANGE MAX(MAX_PRI_NO,MAX_SEC_NO)
#define MAX_FINANCE (6) // Finance number
#define MAX_FINANCE_BCD (3) // Finance number
#define MAX_LAST_LINE (6) // Last line number
#define MAX_LAST_LINE_BCD (3) // BCD encoded last line number
#define MAX_LAST_LINE_NAME (28) // Last line name (chgd fm 25 to 28)
#define MAX_COUNTY_NO (3) // County number
#define MAX_COUNTY_NO_BCD (2) // BCD encoded county number
#define MAX_COUNTY (25) // County name
#define MAX_CRIS (4) // Carrier route
//
// Index key lengths
//
#define MAX_CS_KEY (2) // CS key length
#define MAX_CX_KEY (2) // CX key length
#define MAX_PF_KEY (3) // PF key length
#define MAX_Z4_KEY (9) // Z4 key length
#define MAX_Z5_KEY (3) // Z5 key length
#define MAX_ZX_KEY (4) // PF key length
//
// Other constants
//
#define MAX_ZIP5_CITIES (60) // Maximum number of cities in a ZIP5
#define MAX_CITY_ZIP5 (300) // Maximum number of ZIP5 in a city
#define MAX_POF_ZIP5 (425) // Maximum 5 digit ZIPs in a POF
#define MAX_POF_CITY (16) // Maximum POF's in a city/state
#define MAX_RECORDS (256) // Maximum multiple response records
#define MAX_ZIP4_RECS (256) // Maximum number of records in a ZIP4
//
// POF Tables
//
#define Z4_PF_TBL_DISCARD "z4pfdisc.dat"
#define Z4_PF_TBL_DISCARD_MAX (2048)
#define Z4_PF_TBL_SPLIT "z4pfsplt.dat"
#define Z4_PF_TBL_WORK "z4pfwork.dat"
#if OS_UNIX
#define Z4_PF_TBL_SPLIT_MAX (30000)
#define Z4_PF_TBL_WORK_MAX (30000)
#else
#define Z4_PF_TBL_SPLIT_MAX (20000) //chgd fm 10000
#define Z4_PF_TBL_WORK_MAX (20000) //chgd fm 10000
#endif
//
// City/state compressor bit flags
//
#define CS_BYTE_FOLLOWS (0x80) // Another bit flag byte follows
///// Bit flag byte 1
#define CS1_ZIP5_HI (0x40) // New 5 digit hi range
#define CS1_ZIP5_LO (0x20) // New 5 digit low range
#define CS1_CITY (0x10) // New city name
#define CS1_CITY_ABBREV (0x08) // New city abbreviaiton
#define CS1_STATE (0x04) // New state code
#define CS1_FACILITY (0x02) // New facility code
#define CS1_NO_ZIP5_HI (0x01) // No ZIP5 hi range
///// Bit flag byte 2
#define CS2_FINANCE (0x80) // New finance number
#define CS2_LAST_LINE (0x40) // New last line number
#define CS2_LAST_LINE_NAME (0x20) // New last line name
#define CS2_COUNTY_NO (0x10) // New county number
#define CS2_COUNTY (0x08) // New county name
#define CS2_LL_IS_POF (0x04) // Last line and finance are equal
#define CS2_LL_IS_CITY (0x02) // Last line name and city are same
#define CS2_REC_TYPE (0x01) // New record type
//
// ZIP+4 compressor bit flags
//
#define Z4_BYTE_FOLLOWS (0x8000) // Another bit flag byte follows
///// Word flag 1
#define Z41_UNIT_REC_TYPE (0x4000) // Unit or record type changed
#define Z41_DIR (0x2000) // Directional code changed
#define Z41_CODES (0x1000) // Odd/even codes or alt change
#define Z41_PRI_LO (0x0800) // Primary lo change
#define Z41_PRI_DELTA_LO (0x0400) // Primary lo range delta
#define Z41_PRI_HI (0x0200) // Primary hi change
#define Z41_PRI_DELTA_HI (0x0100) // Primary hi range delta
#define Z41_SEC_LO (0x0080) // Secondary lo change
#define Z41_SEC_HI (0x0040) // Secondary hi change
#define Z41_PRI_NAME (0x0020) // Primary name change
#define Z41_ADDON_LO (0x0010) // Addon lo change
#define Z41_ADDON_HI (0x0008) // Addon hi change
#define Z41_ADDON_LO_HI (0x0004) // Add on hi lo range are equal
#define Z41_SUFFIX1 (0x0002) // Suffix change
#define Z41_SUFFIX2 (0x0001) // Suffix change
///// Bit flag byte 2
#define Z42_PRI_LO_HI (0x80) // Primary hi lo range are equal
#define Z42_SEC_LO_HI (0x40) // Secondary hi lo range are equal
#define Z42_SEC_NAME (0x20) // Secondary name change
#define Z42_SEC_NAME_BLANK (0x10) // Secondary name is blank
#define Z42_ZIP5 (0x08) // ZIP5 change
#define Z42_CRIS (0x04) // CRIS change
#define Z42_LAST_LINE (0x02) // Last line change
#define Z42_FINANCE (0x01) // Finance number
//
// Miscellaneous constants
//
#define Z4_CS_WORD_CACHE (1024) // City/state word cache size
#define Z4_Z4_WORD_CACHE (1024) // ZIP+4 word cache size
#define MAX_PARSE_ELEM (50+5) // Maximum parse stack elements
///// Record stack add/change/delete penalties
#define Z4_REC_ADD (1) // Penalty for add
#define Z4_REC_DEL (2) // Penalty for delete
#define Z4_REC_CHG (2) // Penalty for change
///// Parse abbreviation types
#define Z4_P_ALPHA (0x0001) // Alpha
#define Z4_P_NUMERIC (0x0002) // Numeric
#define Z4_P_OTHER (0x0004) // Other (./-#%& etc...)
#define Z4_P_SUFFIX (0x0008) // Suffix word (always alpha)
#define Z4_P_DIR (0x0010) // Directional
#define Z4_P_UNIT (0x0020) // Unit designator
#define Z4_P_EXCEPT (0x0040) // Exceptional unit designator
#define Z4_P_POB (0x0080) // Post office box words
#define Z4_P_RR (0x0100) // Rural Route word
#define Z4_P_HC (0x0200) // Highway contract word
#define Z4_P_GD (0x0400) // General delivery word
#define Z4_P_PM (0x0800) // Postmaster words
#define Z4_P_ORDINAL (0x1000) // Ordinal words (ST/RD/TH/ND)
#define Z4_P_EOW (0x2000) // End of word
#define Z4_P_CHG (0x4000) // Word was abbreviated or changed
///// Parse flags for various internal functions
#define Z4_P_PRINO (0x0001) // Primary range
#define Z4_P_SECNO (0x0000) // Secondary range
#define Z4_P_SECNO_FORCE (0x0000) // Force extraction even if suffix or dir
///// Tie breaker flags
#define Z4_T_ZIP5 (0x8000) // Record is out of input ZIP5
#define Z4_T_RANGE (0x4000) // Record is out of range
//
// Flags to Z4_INQ::Start && Open
//
#define Z4_INQ_AB (0x0001)
#define Z4_INQ_CX (0x0002)
#define Z4_INQ_CS (0x0004)
#define Z4_INQ_ST (0x0008)
#define Z4_INQ_Z4 (0x0010)
#define Z4_INQ_Z5 (0x0020)
#define Z4_INQ_ZX (0x0040)
#define Z4_INQ_ALL (0x0FFF)
#define Z4_INQ_WRITE (0x8000)
#define Z4_INQ_REINIT (0x4000)
//
// Minimum adjust distances for name matching
//
#define MAX_CS_DIST (10) // City name distance
#define MAX_PRI_DIST (10) // Primary name distance
#define MAX_SEC_DIST (16) // Secondary name distance
//
// These defines are used to access the various tables used by
// the ZIP+4 engine.
//
#define Z4_DATA_FULL (0) // Full spelling
#define Z4_DATA_ABBREV (1) // Abbreviation
#define Z4_DATA_CODE (2) // Coded
#define Z4_DATA_NOVICE (3) // Novice interpretation
#define Z4_DATA_EXPERT (4) // Expert interpretation
//----------------------------------------------------------------------------
// Enumerated data types
//----------------------------------------------------------------------------
typedef enum _Z4_ALT ///// Alternate record indicator
{
Z4_ALT_B = 0, // Base Name
Z4_ALT_A, // Alternate name
Z4_ALT_MAX,
Z4_ALT_INVALID
} Z4_ALT;
typedef enum _Z4_CODE ///// Odd/Even/Both
{
Z4_SPACE = 0,
Z4_BOTH, // Both
Z4_ODD, // Odd
Z4_EVEN, // Even
Z4_CODE_INVALID, // Invalid!
} Z4_CODE;
typedef enum _Z4_CS_TYPE ///// City/state record type
{
Z4_CS_TYPE_POB = 0, // P
Z4_CS_TYPE_NON_UNIQUE, // blank
Z4_CS_TYPE_UNIQUE, // U
Z4_CS_TYPE_MILITARY, // M
Z4_CS_TYPE_MAX,
Z4_CS_TYPE_INVALID,
} Z4_CS_TYPE;
typedef enum _Z4_DIR ///// Directional
{
Z4_DIR_BLANK = 0,
Z4_DIR_N, // North
Z4_DIR_E, // East
Z4_DIR_S, // South
Z4_DIR_W, // West
Z4_DIR_NE, // Northeast
Z4_DIR_SE, // Southeast
Z4_DIR_SW, // Southwest
Z4_DIR_NW, // Northwest
Z4_DIR_MAX,
Z4_DIR_INVALID
} Z4_DIR;
typedef enum _Z4_FACILITY ///// Facility code
{
Z4_FACILITY_AIRPORT, // A
Z4_FACILITY_BRANCH, // B
Z4_FACILITY_COMMUNITY_PO, // C
Z4_FACILITY_AREA_DISTRBUTION, // D
Z4_FACILITY_SECTIONAL_CENTER, // E
Z4_FACILITY_DELIVERY_DISTRIBUTION, // F
Z4_FACILITY_GENERAL_MAIL, // G
Z4_FACILITY_BULK_MAIL_CENTER, // K
Z4_FACILITY_MONEY_ORDER, // M
Z4_FACILITY_NON_POSTAL, // N
Z4_FACILITY_OTHER, // O
Z4_FACILITY_PO, // P
Z4_FACILITY_STATION, // S
Z4_FACILITY_URBANIZATION, // U
Z4_FACILITY_MAX,
Z4_FACILITY_INVALID
} Z4_FACILITY;
typedef enum _Z4_REC_CODE ///// Record stack code
{
Z4_REC_BEST, // Best record
Z4_REC_FIRM, // Best firm
Z4_REC_FIRST = Z4_REC_FIRM, // First record
Z4_REC_BLD, // Best building
Z4_REC_BLD_DFT, // Best building default
Z4_REC_RR, // Best RR
Z4_REC_RR_DFT, // Best RR default
Z4_REC_OTHER, // Best other (street/pob/postmaster)
Z4_REC_LAST = Z4_REC_OTHER, // Last record
Z4_REC_MAX
} Z4_REC_CODE;
typedef enum _Z4_RESULT ///// Result codes
{
Z4_RESULT_FAILURE = 0, // Failed
Z4_RESULT_SUCCESS, // Generic success
Z4_RESULT_ABORT, // Aborted by user
Z4_RESULT_INV_ST, // Invalid state
Z4_RESULT_INV_CITY, // Invalid city
Z4_RESULT_INV_CSZ, // Invalid city/state or ZIP
Z4_RESULT_NOT_FOUND, // Address/ZIP4/ZIP5/CS not found
Z4_RESULT_MULTI, // Multiple match
Z4_RESULT_EXACT, // Exact match
} Z4_RESULT;
typedef enum _Z4_RQ ///// Request codes
{
Z4_RQ_DFT = 0, // Default request
Z4_RQ_CS, // City/state
Z4_RQ_Z4, // Address inquiry
Z4_RQ_Z5, // ZIP 5
Z4_RQ_ZX, // ZIP 4
} Z4_RQ;
typedef enum _Z4_STATE ///// State code
{ // This table must match the array in
Z4_ST_INVALID = 0, // zbstname.c. 0 must be an invalid state!
Z4_ST_FIRST = 1,
#if USE_STATES_ONLY==0
Z4_ST_AA = Z4_ST_FIRST, // Armed Forces America
Z4_ST_AE, // Armed Forces Europe
Z4_ST_AK, // Alaska
#else
Z4_ST_AK = Z4_ST_FIRST, // Alaska
#endif
Z4_ST_AL, // Alabama
#if USE_STATES_ONLY==0
Z4_ST_AP, // Armed Forces Pacific
#endif
Z4_ST_AR, // Arkansas
#if USE_STATES_ONLY==0
Z4_ST_AS, // American Somoa
#endif
Z4_ST_AZ, // Arizona
Z4_ST_CA, // California
Z4_ST_CO, // Colorado
Z4_ST_CT, // Connecticut
Z4_ST_DC, // District of Columbia
Z4_ST_DE, // Delaware
Z4_ST_FL, // Florida
#if USE_STATES_ONLY==0
Z4_ST_FM, // Federated States of Micronesia
#endif
Z4_ST_GA, // Georgia
#if USE_STATES_ONLY==0
Z4_ST_GU, // Guam
#endif
Z4_ST_HI, // Hawaii
Z4_ST_IA, // Iowa
Z4_ST_ID, // Idaho
Z4_ST_IL, // Illinois
Z4_ST_IN, // Indiana
Z4_ST_KS, // Kansas
Z4_ST_KY, // Kentucky
Z4_ST_LA, // Louisiana
Z4_ST_MA, // Massachussetts
Z4_ST_MD, // Maryland
Z4_ST_ME, // Maine
#if USE_STATES_ONLY==0
Z4_ST_MH, // Marshall Islands
#endif
Z4_ST_MI, // Michigan
Z4_ST_MN, // Minnesota
Z4_ST_MO, // Missouri
#if USE_STATES_ONLY==0
Z4_ST_MP, // Northern Mariana Islands
#endif
Z4_ST_MS, // Mississippi
Z4_ST_MT, // Montana
Z4_ST_NC, // North Carolina
Z4_ST_ND, // North Dakota
Z4_ST_NE, // Nebraska
Z4_ST_NH, // New Hampshire
Z4_ST_NJ, // New Jersey
Z4_ST_NM, // New Mexico
Z4_ST_NV, // Nevada
Z4_ST_NY, // New York
Z4_ST_OH, // Ohio
Z4_ST_OK, // Oklahoma
Z4_ST_OR, // Oregon
Z4_ST_PA, // Pennsylvania
#if USE_STATES_ONLY==0
Z4_ST_PR, // Puerto Rico
Z4_ST_PW, // Palau
#endif
Z4_ST_RI, // Rhode Island
Z4_ST_SC, // South Carolina
Z4_ST_SD, // South Dakota
Z4_ST_TN, // Tennessee
Z4_ST_TX, // Texas
Z4_ST_UT, // Utah
Z4_ST_VA, // Virginia
#if USE_STATES_ONLY==0
Z4_ST_VI, // Virgin Islands
#endif
Z4_ST_VT, // Vermont
Z4_ST_WA, // Washington
Z4_ST_WI, // Wisconsin
Z4_ST_WV, // West Virginia
Z4_ST_WY, // Wyoming
Z4_ST_LAST = Z4_ST_WY,
Z4_ST_MAX,
Z4_ST_CODE_MASK = 0x00FF, // Two digit state codes only
Z4_ST_CODE = 0x0100, // Two digit state codes only
Z4_ST_SPELLED_OUT = 0x0200, // Fully spelled out state name
Z4_ST_ABBREV = 0x0400, // Abbreviated state name
Z4_ST_ALL = (signed)0xFF00, // All state words, was FF00
} Z4_STATE;
typedef enum _Z4_TYPE ///// ZIP+4 record type
{
Z4_TYPE_ST = 0, // Street // chgd fm 10 to S
Z4_TYPE_POB, // PO BOX // chgd fm 14 to P
Z4_TYPE_RR, // Rural Route // chgd fm 18 to R
Z4_TYPE_HD, // Highrise // chgd fm 20 to H
Z4_TYPE_FM, // Firm // chgd fm 21 to F
Z4_TYPE_PM, // Postmaster // chgd fm 22 to M
Z4_TYPE_GD, // General Delivery // chgd fm 26 to G
Z4_TYPE_MAX,
Z4_TYPE_INVALID,
} Z4_TYPE;
typedef enum _Z4_UNIT ///// Directional
{
Z4_UNIT_BLANK = 0, // Blank
Z4_UNIT_POUND, // Pound sign (same as blank
Z4_UNIT_APT, // Apartment
Z4_UNIT_BOX, // Box (not postal standard!)
Z4_UNIT_BLDG, // Building
Z4_UNIT_DEPT, // Department
Z4_UNIT_FL, // Floor
Z4_UNIT_HNGR, // Hanger
Z4_UNIT_LOT, // Lot
Z4_UNIT_PIER, // Peir
Z4_UNIT_RM, // Room
Z4_UNIT_SLIP, // Slip
Z4_UNIT_STE, // Suite
Z4_UNIT_STOP, // Stop
Z4_UNIT_TRLR, // Trailer
Z4_UNIT_UNIT, // Unit
///// Exceptional unit designators
Z4_UNIT_BSMT, // Basement
Z4_UNIT_EXCEPT = Z4_UNIT_BSMT,
Z4_UNIT_FRNT, // Front
Z4_UNIT_LBBY, // Lobby
Z4_UNIT_LOWR, // Lower
Z4_UNIT_OFC, // Office
Z4_UNIT_PH, // Penthouse
Z4_UNIT_REAR, // Read
Z4_UNIT_SIDE, // Side
Z4_UNIT_UPPR, // Upper
Z4_UNIT_MAX,
} Z4_UNIT;
typedef USHORT Z4_SUFFIX;
BASETYPE(Z4_SUFFIX);
//----------------------------------------------------------------------------
// Structures
//----------------------------------------------------------------------------
typedef struct _Z4_AB ///// Abbreviation structure
{
SIZET cWord; // Word
SIZET cFull; // Spelled out word
SIZET cAbbrev; // Correct abbreviation
FLAG16 fs; // Abbreviation flags
} Z4_AB;
BASETYPE(Z4_AB);
typedef struct _Z4_CS ///// City/state record
{
RECID recid; // Record id
CHAR szFinance[MAX_FINANCE+1]; // Finance number
CHAR szZip5Hi[MAX_ZIP5+1]; // ZIP5 high range
CHAR szZip5Lo[MAX_ZIP5+1]; // ZIP5 low range
CHAR szCity[MAX_CITY+1]; // City name
CHAR szCityAbbrev[MAX_CITY_ABBREV+1]; // City abbreviation
CHAR szLastLine[MAX_LAST_LINE+1]; // Last line number
CHAR szLastLineName[MAX_LAST_LINE_NAME+1]; // Last line name
CHAR szCountyNo[MAX_COUNTY_NO+1]; // County number
CHAR szCounty[MAX_COUNTY+1]; // County name
Z4_FACILITY facility; // Facility code
Z4_CS_TYPE rectype; // Record type
Z4_STATE state; // State code
} Z4_CS;
BASETYPE(Z4_CS);
typedef struct _Z4_CS_BLK ///// City/state expander data structure
{
PVOID pcache; // Word cache data
Z4_CS cs; // Current record
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_CS_BLK;
BASETYPE(Z4_CS_BLK);
typedef struct _Z4_CX ///// City cross reference record
{
RECID recid; // Record id
Z4_STATE state; // State code
CHAR szCity[MAX_CITY+1]; // City name
CHAR szPO[MAX_CITY+1]; // Post office name if facility code '9'
SIZET cFinance; // Number of finance # in cs
BYTE abFinance[MAX_POF_CITY][MAX_FINANCE_BCD]; // Finance
SIZET cZip5; // List of 5 digit ZIPs
BYTE abZip5[MAX_CITY_ZIP5][MAX_ZIP5_BCD];
} Z4_CX;
BASETYPE(Z4_CX);
typedef struct _Z4_CX_BLK // City cross reference expander data structure
{
Z4_CX cx; // Current city/state record
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_CX_BLK;
BASETYPE(Z4_CX_BLK);
typedef struct _Z4_NO ///// Range comparison element
{
SIZET cNo; // Number of components
CHAR szNo[MAX_RANGE][MAX_RANGE+1]; // Components
BOOL afDash[MAX_RANGE]; // Dash or period separator after range?
BOOL afAlpha[MAX_RANGE]; // Range is alpha?
SIZET cFract; // Fraction value
Z4_CODE code; // Range code
} Z4_NO;
BASETYPE(Z4_NO);
typedef struct _Z4_PARSE_ELEM ///// Parse stack element
{
SIZET cLen; // Length of word
SIZET cWord; // Offset of word (may be abbreviated)
SIZET cFull; // Offset of spelled out word
FLAG16 fs; // Flags
} Z4_PARSE_ELEM;
BASETYPE(Z4_PARSE_ELEM);
typedef struct _Z4_PF ///// POF record
{
RECID recid; // Record id
CHAR szFinance[MAX_FINANCE+1]; // Finance
SIZET cZip5; // List of 5 digit ZIP codes
BYTE abZip5[MAX_POF_ZIP5][MAX_ZIP5_BCD];
} Z4_PF;
BASETYPE(Z4_PF);
typedef struct _Z4_PF_BLK ///// POF expander data structure
{
Z4_PF pf; // Current record
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_PF_BLK;
BASETYPE(Z4_PF_BLK);
typedef struct _Z4_PF_TBL ///// POF table
{
LONG lMax; // Maximum size of table
LONG lSize; // Number of POF's in table
BYTE abPof[1][MAX_FINANCE_BCD]; // List of POF's
} Z4_PF_TBL;
BASETYPE(Z4_PF_TBL);
typedef struct _Z4_SD ///// State detail
{
USHORT usCities; // Number of cities
USHORT usZips; // Number of unqiue ZIP 5's
USHORT usCounties; // Number of counties
USHORT cbCounties; // Size of county data
} Z4_SD;
BASETYPE(Z4_SD);
typedef struct _Z4_SF ///// Suffix table
{
SIZET cAbbrev; // Abbreviated suffix
SIZET cFull; // Spelled out suffix
} Z4_SF;
BASETYPE(Z4_SF);
typedef struct _Z4_ST_TABLE ///// State name table entry
{
PCSZ pcsz; // State name
Z4_STATE code; // State code and flags
} Z4_ST_TABLE;
BASETYPE(Z4_ST_TABLE);
typedef struct _Z4_Z4 ///// ZIP+4 record
{
RECID recid; // Record id
CHAR szFinance[MAX_FINANCE+1]; // Finance number
CHAR szZip5[MAX_ZIP5+1]; // ZIP5
CHAR szLastLine[MAX_LAST_LINE+1]; // Last line number
CHAR szCris[MAX_CRIS+1]; // Carrier route
CHAR szPriName[MAX_PRI_NAME+1]; // Primary name
CHAR szPriLo[MAX_PRI_NO+1]; // Primary range low
CHAR szPriHi[MAX_PRI_NO+1]; // Primary range high
CHAR szSecName[MAX_SEC_NAME+1]; // Secondary name
CHAR szSecHi[MAX_SEC_NO+1]; // Secondary range high
CHAR szSecLo[MAX_SEC_NO+1]; // Secondary range low
CHAR szAddonHi[MAX_ADDON+1]; // Secondary range high
CHAR szAddonLo[MAX_ADDON+1]; // Addon range high
Z4_SUFFIX suffix1; // Suffix 1 (actual)
Z4_SUFFIX suffix2; // Suffix 2 (from primary name)
Z4_CODE seccode; // Secondary odd/even/both code
Z4_CODE pricode; // Primary odd/even/both code
Z4_TYPE rectype; // Record type
Z4_DIR predir; // Pre direction
Z4_DIR postdir; // Post direction
Z4_UNIT unit; // Unit designator
Z4_ALT alt; // Alternate record indicator
BOOL fOrdinal; // Ordinal pri name (ex: 10TH, 1ST)
BOOL fNumeric; // Primary name is all numeric
} Z4_Z4;
BASETYPE(Z4_Z4);
typedef struct _Z4_Z4_BLK ///// ZIP+4 expander data structure
{
PVOID pcache; // Word cache data
Z4_Z4 z4; // Current record
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_Z4_BLK;
BASETYPE(Z4_Z4_BLK);
typedef struct _Z4_REC ///// ZIP+4 stack record
{
SIZET cCount; // # records of this type
Z4_Z4 z4;
SHORT sPriName; // Primary name weight
SHORT sSecName; // Secondary name weight
SIZET cACD; // Add/change/delete penalty
FLAG16 fsTie; // Tie breakers
} Z4_REC;
BASETYPE(Z4_REC);
typedef struct _Z4_Z5 ///// ZIP5 record
{
RECID recid; // Record id
CHAR szZip5[MAX_ZIP5+1]; // ZIP5
CHAR szFinance[MAX_FINANCE+1]; // Finance number
SIZET cCities; // Number of city names
RECID arecid[MAX_ZIP5_CITIES]; // Record id's of city names
} Z4_Z5;
BASETYPE(Z4_Z5);
typedef struct _Z4_Z5_BLK ///// ZIP5 expander data structure
{
RECID recid; // Record id
Z4_Z5 z5; // ZIP 5 record
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_Z5_BLK;
BASETYPE(Z4_Z5_BLK);
typedef struct _Z4_ZX ///// ZIP4 cross reference record
{
RECID recid; // Record id
CHAR szZip5[MAX_ZIP5+1]; // ZIP4
CHAR szAddonLo[MAX_ADDON+1]; // Low addon range
CHAR szAddonHi[MAX_ADDON+1]; // Hi addon range
SIZET cRecords; // Number of records (- 1)
RECID arecid[MAX_ZIP4_RECS]; // Record id of zip+4
} Z4_ZX;
BASETYPE(Z4_ZX);
typedef struct _Z4_ZX_BLK ///// ZIP4 expander data structure
{
RECID recid; // Record id
Z4_ZX zx; // ZX record
ULONG ulZip4; // ZIP4 as long int
PBYTE pb; // Pointer to buffer
SIZET cb; // Size of buffer
SIZET cbNext; // Next byte to decode
} Z4_ZX_BLK;
BASETYPE(Z4_ZX_BLK);
//----------------------------------------------------------------------------
// Globals
// The variables are used by the compressors and expanders so they are
// external
//----------------------------------------------------------------------------
#if COMPILE_CPP //added to compile under MSVC
extern "C"
{
extern CHAR _FAR_ __chWordTable[]; // Word table
extern Z4_AB _FAR_ __abbrevTable[]; // Abbreviation table
}
#else
extern CHAR _FAR_ __chWordTable[]; // Word table
extern Z4_AB _FAR_ __abbrevTable[]; // Abbreviation table
#endif
extern Z4_SF _FAR_ __suffixTable[]; // Suffix table
extern SIZET __cSuffixTable;
#if COMPILE_CPP
extern "C"
extern SIZET __cAbbrevTable;
#else
extern SIZET __cAbbrevTable;
#endif
#define Z4_WORD(x) (__chWordTable + (x))
//----------------------------------------------------------------------------
// Prototypes
//----------------------------------------------------------------------------
#if COMPILE_CPP
extern "C"
{
#endif
//
// z4clean.c
//
PSZ FN_E Z4Clean(PSZ);
//
// z4cscp.c
//
SHORT FN_E Z4CSCompress(PDATACOMP);
//
// z4csex.c
//
BOOL FN_E Z4CSExpand(PZ4_CS_BLK, PZ4_CS);
BOOL FN_E Z4CSExpandInitialize(PZ4_CS_BLK);
BOOL FN_E Z4CSExpandReset(PZ4_CS_BLK, PBYTE, SIZET);
BOOL FN_E Z4CSExpandTerminate(PZ4_CS_BLK);
//
// z4cskey.c
//
VOID FN_E Z4CSKey(PBYTE, Z4_STATE, PCSZ);
//
// z4csndx.c
//
BOOL FN_E Z4CSIndex(PDI_INDEX);
//
// z4cxcp.c
//
SHORT FN_E Z4CXCompress(PDATACOMP);
//
// z4cxex.c
//
BOOL FN_E Z4CXExpand(PZ4_CX_BLK, PZ4_CX);
BOOL FN_E Z4CXExpandInitialize(PZ4_CX_BLK);
BOOL FN_E Z4CXExpandReset(PZ4_CX_BLK, PBYTE, SIZET);
BOOL FN_E Z4CXExpandTerminate(PZ4_CX_BLK);
//
// z4cxkey.c
//
VOID FN_E Z4CXKey(PBYTE pb, Z4_STATE state, PCSZ pcszCity);
//
// z4cxndx.c
//
BOOL FN_E Z4CXIndex(PDI_INDEX);
//
// z4data.c
//
PCSZ FN_E Z4State(Z4_STATE, SIZET);
Z4_STATE FN_E Z4FindState(PCSZ);
PCSZ FN_E Z4CSRecordType(Z4_CS_TYPE, SIZET);
Z4_CS_TYPE FN_E Z4FindCSRecordType(PCSZ);
PCSZ FN_E Z4Facility(Z4_FACILITY, SIZET);
Z4_FACILITY FN_E Z4FindFacility(PCSZ);
PCSZ FN_E Z4Z4RecordType(Z4_TYPE, SIZET);
Z4_TYPE FN_E Z4FindZ4RecordType(PCSZ);
PCSZ FN_E Z4Directional(Z4_DIR, SIZET);
Z4_DIR FN_E Z4FindDirectional(PCSZ);
PCSZ FN_E Z4Unit(Z4_UNIT, SIZET);
Z4_UNIT FN_E Z4FindUnit(PCSZ);
PCSZ FN_E Z4Code(Z4_CODE, SIZET);
Z4_CODE FN_E Z4FindCode(PCSZ);
PCSZ FN_E Z4Alt(Z4_ALT, SIZET);
Z4_ALT FN_E Z4FindAlt(PCSZ);
// z4pfcp.c
//
SHORT FN_E Z4PFCompress(PDATACOMP);
//
// z4pfex.c
//
BOOL FN_E Z4PFExpand(PZ4_PF_BLK, PZ4_PF);
BOOL FN_E Z4PFExpandInitialize(PZ4_PF_BLK);
BOOL FN_E Z4PFExpandReset(PZ4_PF_BLK, PBYTE, SIZET);
BOOL FN_E Z4PFExpandTerminate(PZ4_PF_BLK);
//
// z4pfkey.c
//
VOID FN_E Z4PFKey(PBYTE, PCSZ);
//
// z4pfndx.c
//
BOOL FN_E Z4PFIndex(PDI_INDEX);
//
// z4pof.c
//
BOOL FN_E Z4PofAdd(PZ4_PF_TBL, PCSZ);
VOID FN_E Z4PofClear(PZ4_PF_TBL);
VOID FN_E Z4PofCopy(PZ4_PF_TBL, PZ4_PF_TBL, LONG);
BOOL FN_E Z4PofCreate(PZ4_PF_TBL _FAR_ *, LONG);
VOID FN_E Z4PofDelete(PZ4_PF_TBL, LONG);
VOID FN_E Z4PofDestroy(PZ4_PF_TBL);
LONG FN_E Z4PofFind(PZ4_PF_TBL, PCSZ);
BOOL FN_E Z4PofRead(PZ4_PF_TBL, PCSZ);
VOID FN_E Z4PofShow(PZ4_PF_TBL);
BOOL FN_E Z4PofWrite(PZ4_PF_TBL, PCSZ);
//
// z4sffile.c
//
PCSZ FN_E Z4SuffixAbbrev(Z4_SUFFIX);
BOOL FN_E Z4SuffixFindAbbrev(PCSZ, PZ4_SUFFIX);
BOOL FN_E Z4SuffixFindFull(PCSZ, PZ4_SUFFIX);
PCSZ FN_E Z4SuffixFull(Z4_SUFFIX);
//
// z4z4cp.c
//
SHORT FN_E Z4Z4Compress(PDATACOMP);
PSZ FN_E Z4Z4CompressPriName(PSZ, PSZ, PZ4_SUFFIX, PBOOL);
PSZ FN_E Z4Z4CompressRange(PSZ psz);
//
// z4z4ex.c
//
BOOL FN_E Z4Z4Expand(PZ4_Z4_BLK, PZ4_Z4);
BOOL FN_E Z4Z4ExpandInitialize(PZ4_Z4_BLK);
BOOL FN_E Z4Z4ExpandReset(PZ4_Z4_BLK, PBYTE, SIZET);
BOOL FN_E Z4Z4ExpandTerminate(PZ4_Z4_BLK);
//
// z4z4key.c
//
VOID FN_E Z4Z4Key(PBYTE, PCSZ, PCSZ, PCSZ);
//
// z4z4ndx.c
//
BOOL FN_E Z4Z4Index(PDI_INDEX);
//
// z4z4cnt.c
//
BOOL FN_E Z4Z5CountRead(PLONG, SIZET);
BOOL FN_E Z4Z5CountWrite(PLONG, SIZET);
//
// z4z5cp.c
//
SHORT FN_E Z4Z5Compress(PDATACOMP pdatacomp);
//
// z4z5ex.c
//
BOOL FN_E Z4Z5Expand(PZ4_Z5_BLK, PZ4_Z5);
BOOL FN_E Z4Z5ExpandInitialize(PZ4_Z5_BLK);
BOOL FN_E Z4Z5ExpandReset(PZ4_Z5_BLK, PBYTE, SIZET);
BOOL FN_E Z4Z5ExpandTerminate(PZ4_Z5_BLK);
//
// z4z5key.c
//
VOID FN_E Z4Z5Key(PBYTE, PCSZ);
//
// z4z5ndx.c
//
BOOL FN_E Z4Z5Index(PDI_INDEX);
//
// z4zxcp.c
//
SHORT FN_E Z4ZXCompress(PDATACOMP);
//
// z4zxex.c
//
BOOL FN_E Z4ZXExpand(PZ4_ZX_BLK, PZ4_ZX);
BOOL FN_E Z4ZXExpandInitialize(PZ4_ZX_BLK);
BOOL FN_E Z4ZXExpandReset(PZ4_ZX_BLK, PBYTE, SIZET);
BOOL FN_E Z4ZXExpandTerminate(PZ4_ZX_BLK);
//
// z4zxkey.c
//
VOID FN_E Z4ZXKey(PBYTE, PCSZ);
//
// z4zxndx.c
//
BOOL FN_E Z4ZXIndex(PDI_INDEX);
#if COMPILE_CPP
}
#endif
//----------------------------------------------------------------------------
// C++ Code
//----------------------------------------------------------------------------
#if COMPILE_CPP
//----------------------------------------------------------------------------
// Class definitions
//----------------------------------------------------------------------------
CLASSDEF(Z4_AB_FILE);
CLASSDEF(Z4_CS_FILE);
CLASSDEF(Z4_CX_FILE);
CLASSDEF(Z4_SD_FILE);
CLASSDEF(Z4_ST_FILE);
CLASSDEF(Z4_Z4_FILE);
CLASSDEF(Z4_Z5_FILE);
CLASSDEF(Z4_ZX_FILE);
CLASSDEF(Z4_INQ);
CLASSDEF(Z4_MATCH);
CLASSDEF(Z4_PARSE);
CLASSDEF(Z4_RANGE);
CLASSDEF(Z4_STANDARDIZE);
CLASSDEF(Z4_VAL_CSZ);
//----------------------------------------------------------------------------
// Typedefs
//----------------------------------------------------------------------------
typedef BOOL (FN_E *PFNZIP4)(SHORT = 0); // ZIP+4 callback function
//----------------------------------------------------------------------------
// Abbreviation file
//----------------------------------------------------------------------------
#define Z4_AB_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_AB_FILE : public Z4_AB_FILE_PARENT
{
SIZET cCurrent; // Current entry
public:
FN_M Z4_AB_FILE();
virtual FN_M ~Z4_AB_FILE() {}
PCSZ FN_M Abbreviation() const;
virtual BOOL FN_M Destroy(BOOL = TRUE);
FLAG16 FN_M Flags() const;
BOOL FN_M Find(PCSZ);
BOOL FN_M First();
PCSZ FN_M Full() const;
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
BOOL FN_M Next();
BOOL FN_M Open();
PCSZ FN_M Word() const;
private:
static int __ab_find__(const void *, const void *);
};
//----------------------------------------------------------------------------
// Class Z4_CS_FILE
//----------------------------------------------------------------------------
#define Z4_CS_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_CS_FILE : public Z4_CS_FILE_PARENT
{
static PCSZ pcszLogical; // Logical file name
HLF hlf; // Logical file handle
HLF hlfRecNo; // Record number index handle
LONG lRecs; // Number of records in file
LONG lBlocks; // Number of blocks in file
LONG lBlock; // Current block
USHORT usBlockSize; // Block size
BOOL fBlock; // Block is pending in expander
BOOL fOffset; // Block has started expanding
USHORT usOffset; // Current record in current block
Z4_CS_BLK z4_cs_blk; // Expander data
PBYTE pb; // Data for current block
public:
FN_M Z4_CS_FILE();
FN_M Z4_CS_FILE(RCZ4_CS_FILE);
virtual FN_M ~Z4_CS_FILE();
BOOL FN_M Best(RZ4_CS, RZ4_Z5, PCSZ = NULL);
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M Find(RZ4_CS, Z4_STATE, PCSZ = NULL);
BOOL FN_M First(RZ4_CS, Z4_STATE, PCSZ = NULL);
BOOL FN_M First(RZ4_CS, LONG = 0);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsError() const;
virtual BOOL FN_M IsValid() const;
BOOL FN_M Next(RZ4_CS);
BOOL FN_M Open();
RCZ4_CS_FILE FN_M operator=(RCZ4_CS_FILE);
BOOL FN_M Record(RZ4_CS, LONG = -1);
BOOL FN_M Record(RZ4_CS, RECID);
LONG FN_M RecordNo();
LONG FN_M Records() const
{
return lRecs;
}
};
//----------------------------------------------------------------------------
// Class Z4_CX_FILE
//----------------------------------------------------------------------------
#define Z4_CX_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_CX_FILE : public Z4_CX_FILE_PARENT
{
static PCSZ pcszLogical; // Logical file name
HLF hlf; // Logical file handle
HLF hlfRecNo; // Record number index handle
LONG lRecs; // Number of records in file
LONG lBlocks; // Number of blocks in file
LONG lBlock; // Current block
USHORT usBlockSize; // Block size
BOOL fBlock; // Block is pending in expander
BOOL fOffset; // Block has started expanding
USHORT usOffset; // Current record in current block
Z4_CX_BLK z4_cx_blk; // Expander data
PBYTE pb; // Data for current block
public:
FN_M Z4_CX_FILE();
FN_M Z4_CX_FILE(RCZ4_CX_FILE);
virtual FN_M ~Z4_CX_FILE();
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M Find(RZ4_CX, Z4_STATE, PCSZ = NULL);
BOOL FN_M First(RZ4_CX, Z4_STATE, PCSZ = NULL);
BOOL FN_M First(RZ4_CX, LONG = 0);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsError() const;
virtual BOOL FN_M IsValid() const;
BOOL FN_M Next(RZ4_CX);
BOOL FN_M Open();
RCZ4_CX_FILE FN_M operator=(RCZ4_CX_FILE);
BOOL FN_M Record(RZ4_CX, LONG = -1);
BOOL FN_M Record(RZ4_CX, RECID);
LONG FN_M RecordNo();
LONG FN_M Records() const
{
return lRecs;
}
};
//----------------------------------------------------------------------------
// Class Z4_SD_FILE
//----------------------------------------------------------------------------
#define Z4_SD_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_SD_FILE : public Z4_SD_FILE_PARENT
{
BOOL fValid; // File valid?
Z4_SD sd; // State detail data
PCHAR pchCounties; // Pointer to list of counties
public:
FN_M Z4_SD_FILE(Z4_STATE = Z4_ST_INVALID);
FN_M Z4_SD_FILE(RCZ4_SD_FILE);
virtual FN_M ~Z4_SD_FILE();
USHORT FN_M Cities() const
{
return sd.usCities;
}
USHORT FN_M Counties() const
{
return sd.usCounties;
}
PCHAR FN_M CountyNames() const
{
return pchCounties ? pchCounties: "";
}
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M Get(Z4_STATE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsValid() const;
RCZ4_SD_FILE FN_M operator=(RCZ4_SD_FILE);
USHORT FN_M Zips() const
{
return sd.usZips;
}
};
//----------------------------------------------------------------------------
// Z4_ST_FILE
//----------------------------------------------------------------------------
#define Z4_ST_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_ST_FILE : public Z4_ST_FILE_PARENT
{
static Z4_ST_TABLE aiStateTable[];
Z4_STATE mask; // Mask for state names
SIZET cCurrent; // Current entry
public:
FN_M Z4_ST_FILE(Z4_STATE = Z4_ST_ALL);
virtual FN_M ~Z4_ST_FILE() {}
PCSZ FN_M Abbreviation();
static PCSZ FN_M Abbreviation(Z4_STATE);
Z4_STATE FN_M Code() const
{
// return aiStateTable[cCurrent].code & Z4_ST_CODE_MASK; //org code
return (Z4_STATE)(aiStateTable[cCurrent].code & Z4_ST_CODE_MASK);
}
SIZET FN_M Current() const
{
return cCurrent;
}
virtual BOOL FN_M Destroy(BOOL = TRUE);
Z4_STATE FN_M Find(PCSZ);
Z4_STATE FN_M First();
Z4_STATE FN_M First(PCSZ);
Z4_STATE FN_M Flags() const
{
//return aiStateTable[cCurrent].code & Z4_ST_ALL; //org code
return (Z4_STATE)(aiStateTable[cCurrent].code & Z4_ST_ALL);
}
PCSZ FN_M Full();
static PCSZ FN_M Full(Z4_STATE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
Z4_STATE FN_M Next();
BOOL FN_M Open();
FN_M operator PCSZ() const
{
return aiStateTable[cCurrent].pcsz;
}
FN_M operator PSZ() const
{
return (PSZ)aiStateTable[cCurrent].pcsz;
}
PCSZ FN_M Record(LONG);
LONG FN_M RecordNo();
SIZET FN_M Records();
VOID FN_M SetMask(Z4_STATE _mask = Z4_ST_ALL)
{
mask = _mask;
return ;
}
};
//----------------------------------------------------------------------------
// Class Z4_Z4_FILE
//----------------------------------------------------------------------------
#define Z4_Z4_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_Z4_FILE : public Z4_Z4_FILE_PARENT
{
static PCSZ pcszLogical; // Logical file name
HLF hlf; // Logical file handle
HLF hlfRecNo; // Record number index handle
LONG lRecs; // Number of records in file
LONG lBlocks; // Number of blocks in file
LONG lBlock; // Current block
USHORT usBlockSize; // Block size
BOOL fBlock; // Block is pending in expander
BOOL fOffset; // Block has started expanding
USHORT usOffset; // Current record in current block
Z4_Z4_BLK z4_z4_blk; // Expander data
PBYTE pb; // Data for current block
public:
FN_M Z4_Z4_FILE();
FN_M Z4_Z4_FILE(RCZ4_Z4_FILE);
virtual FN_M ~Z4_Z4_FILE();
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M First(RZ4_Z4, PCSZ, PCSZ = NULL, PCSZ = NULL);
BOOL FN_M First(RZ4_Z4, LONG = 0);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsError() const;
virtual BOOL FN_M IsValid() const;
BOOL FN_M Next(RZ4_Z4);
BOOL FN_M Open();
RCZ4_Z4_FILE FN_M operator=(RCZ4_Z4_FILE);
BOOL FN_M Record(RZ4_Z4, LONG = -1);
BOOL FN_M Record(RZ4_Z4, RECID);
LONG FN_M RecordNo();
LONG FN_M Records() const
{
return lRecs;
}
};
//----------------------------------------------------------------------------
// Class Z4_Z5_FILE
//----------------------------------------------------------------------------
#define Z4_Z5_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_Z5_FILE : public Z4_Z5_FILE_PARENT
{
static PCSZ pcszLogical; // Logical file name
HLF hlf; // Logical file handle
HLF hlfRecNo; // Record number index handle
LONG lRecs; // Number of records in file
LONG lBlocks; // Number of blocks in file
LONG lBlock; // Current block
USHORT usBlockSize; // Block size
BOOL fBlock; // Block is pending in expander
BOOL fOffset; // Block has started expanding
USHORT usOffset; // Current record in current block
Z4_Z5_BLK z4_z5_blk; // Expander data
PBYTE pb; // Data for current block
public:
FN_M Z4_Z5_FILE();
FN_M Z4_Z5_FILE(RCZ4_Z5_FILE);
virtual FN_M ~Z4_Z5_FILE();
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M Find(RZ4_Z5, PCSZ);
BOOL FN_M First(RZ4_Z5, PCSZ);
BOOL FN_M First(RZ4_Z5, LONG = 0);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsError() const;
virtual BOOL FN_M IsValid() const;
BOOL FN_M Next(RZ4_Z5);
BOOL FN_M Open();
RCZ4_Z5_FILE FN_M operator=(RCZ4_Z5_FILE);
BOOL FN_M Record(RZ4_Z5, LONG = -1);
BOOL FN_M Record(RZ4_Z5, RECID);
LONG FN_M RecordNo();
LONG FN_M Records() const
{
return lRecs;
}
};
//----------------------------------------------------------------------------
// Class Z4_ZX_FILE
//----------------------------------------------------------------------------
#define Z4_ZX_FILE_PARENT CL_OBJECT
class CLASSTYPE Z4_ZX_FILE : public Z4_ZX_FILE_PARENT
{
static PCSZ pcszLogical; // Logical file name
HLF hlf; // Logical file handle
HLF hlfRecNo; // Record number index handle
LONG lRecs; // Number of records in file
LONG lBlocks; // Number of blocks in file
LONG lBlock; // Current block
USHORT usBlockSize; // Block size
BOOL fBlock; // Block is pending in expander
BOOL fOffset; // Block has started expanding
USHORT usOffset; // Current record in current block
Z4_ZX_BLK z4_zx_blk; // Expander data
PBYTE pb; // Data for current block
public:
FN_M Z4_ZX_FILE();
FN_M Z4_ZX_FILE(RCZ4_ZX_FILE);
virtual FN_M ~Z4_ZX_FILE();
virtual BOOL FN_M Destroy(BOOL = TRUE);
BOOL FN_M Find(RZ4_ZX, PCSZ);
BOOL FN_M First(RZ4_ZX, PCSZ);
BOOL FN_M First(RZ4_ZX, LONG = 0);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
virtual BOOL FN_M IsError() const;
virtual BOOL FN_M IsValid() const;
BOOL FN_M Next(RZ4_ZX);
BOOL FN_M Open();
RCZ4_ZX_FILE FN_M operator=(RCZ4_ZX_FILE);
BOOL FN_M Record(RZ4_ZX, LONG = -1);
BOOL FN_M Record(RZ4_ZX, RECID);
LONG FN_M RecordNo();
LONG FN_M Records() const
{
return lRecs;
}
};
//----------------------------------------------------------------------------
// Class Z4_VAL_CSZ
//----------------------------------------------------------------------------
#define Z4_VAL_CSZ_PARENT CL_OBJECT
class CLASSTYPE Z4_VAL_CSZ : public Z4_VAL_CSZ_PARENT
{
BOOL fIsValZ5; // Valid ZIP5 record?
BOOL fIsValCS; // Valid CS record?
public:
CHAR szZip5[MAX_ZIP5+1]; // Input ZIP5
CHAR szZ5Finance[MAX_FINANCE+1]; // ZIP5 finance
SIZET cFinance; // Number of finance #'s
CHAR aszCSFinance[MAX_POF_CITY+1][MAX_FINANCE+1]; // CS finance list
FN_M Z4_VAL_CSZ();
FN_M Z4_VAL_CSZ(RCZ4_VAL_CSZ);
virtual FN_M ~Z4_VAL_CSZ();
VOID FN_M Clear();
BOOL FN_M CS(PCSZ, Z4_STATE);
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
BOOL FN_M IsValidCS() const
{
return fIsValCS;
}
BOOL FN_M IsValidZ5() const
{
return fIsValZ5;
}
BOOL FN_M Z5(PCSZ);
};
//----------------------------------------------------------------------------
// Class Z4_PARSE
//----------------------------------------------------------------------------
#define Z4_PARSE_PARENT CL_OBJECT
class CLASSTYPE Z4_PARSE : public Z4_PARSE_PARENT
{
static SIZET cBuf; // Amount of buffer used!
static CHAR szBuffer[256]; // Parse buffer size
static SIZET cStack; // Parse stack size
static Z4_PARSE_ELEM pelem[MAX_PARSE_ELEM]; // Stack elements
public:
CHAR szAddr1[MAX_ADDR_LINE+1]; // Input address line 1
CHAR szAddr2[MAX_ADDR_LINE+1]; // Input address line 2
CHAR szLastLine[MAX_ADDR_LINE+1]; // Input last line
CHAR szPriNoReformat[MAX_RANGE+1]; // Reformatted primary number
CHAR szPriNo[MAX_RANGE+1]; // Parsed primary number
Z4_DIR predir; // Parsed predirection
CHAR szPriName[MAX_PRI_NAME+1]; // Parsed primary name
BOOL fPriNumeric; // Primary name is numeric
Z4_SUFFIX suffix1; // Parsed suffix 1
Z4_SUFFIX suffix2; // Parsed suffix 2
Z4_DIR postdir; // Parsed post direction
Z4_UNIT unit; // Parsed unit designator
CHAR szSecNo[MAX_RANGE+1]; // Parsed secondary number
CHAR szSecName[MAX_SEC_NAME+1]; // Parsed secondary name
CHAR szCity[MAX_CITY+1]; // Parsed city
BOOL fInvState; // Invalid city/state
Z4_STATE state; // Parsed state
CHAR szZip5[MAX_ZIP5+1]; // Parsed 5 digit
CHAR szAddon[MAX_ADDON+1]; // Parsed addon
CHAR szZip4[MAX_ZIP4+1]; // Parsed ZIP+4
FN_M Z4_PARSE();
FN_M Z4_PARSE(RCZ4_PARSE);
virtual FN_M ~Z4_PARSE();
VOID FN_M Clear();
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
BOOL FN_M LastLine(PCSZ, PCSZ = NULL, PCSZ = NULL);
BOOL FN_M Primary(PCSZ);
BOOL FN_M Secondary(PCSZ);
protected:
VOID FN_M Abbreviate();
SIZET FN_M AddString(PCCHAR, SIZET = 0);
VOID FN_M AvenueX();
VOID FN_M Break(PCSZ);
BOOL FN_M City();
VOID FN_M Clean();
VOID FN_M Collapse();
PCSZ FN_M Combine(PSZ, SIZET, SIZET = 0, SIZET = 0xFFFF, BOOL = TRUE);
VOID FN_M Delete(SIZET, SIZET = 1);
VOID FN_M Ordinal();
BOOL FN_M POB();
VOID FN_M PostDir();
VOID FN_M PreDir();
VOID FN_M PriName();
VOID FN_M PriNo();
BOOL FN_M Range(PSZ, SIZET, SIZET, FLAG16);
BOOL FN_M RRHC();
VOID FN_M SecNo();
BOOL FN_M State();
Z4_SUFFIX FN_M Suffix();
PSZ FN_M Word(SIZET cWord)
{
return szBuffer + cWord;
}
BOOL FN_M Zip4();
};
//----------------------------------------------------------------------------
// Class Z4_RANGE
//----------------------------------------------------------------------------
#define Z4_RANGE_PARENT CL_OBJECT
class CLASSTYPE Z4_RANGE : public Z4_RANGE_PARENT
{
CHAR szNo[MAX_RANGE+1], szLo[MAX_RANGE+1], szHi[MAX_RANGE+1];
Z4_NO no, lo, hi;
public:
FN_M Z4_RANGE();
FN_M Z4_RANGE(RCZ4_RANGE);
virtual FN_M ~Z4_RANGE();
Z4_CODE FN_M Code() const
{
return no.code;
}
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
BOOL FN_M Primary(PCSZ, PCSZ, PCSZ, Z4_CODE);
BOOL FN_M Secondary(PCSZ, PCSZ, PCSZ, Z4_CODE);
private:
BOOL FN_M Break(PCSZ, RZ4_NO);
BOOL FN_M Compare();
BOOL FN_M Exception();
BOOL FN_M Input(PSZ, PCSZ, SIZET);
BOOL FN_M Validate();
};
//----------------------------------------------------------------------------
// Class Z4_MATCH
//----------------------------------------------------------------------------
#define Z4_MATCH_PARENT CL_OBJECT
class CLASSTYPE Z4_MATCH : public Z4_MATCH_PARENT
{
Z4_RANGE range; // Range class
Z4_VAL_CSZ valcsz; // Validate C/S/Z class
PZ4_PARSE pparse; // Parse data pointer
TIMET timetLast;
BOOL fAbort; // Abort flag
public:
///// Other
PFNZIP4 pfnzip4; // Call back
///// Matched records
Z4_REC rec[Z4_REC_MAX]; // Matched record stack
///// Record stack
SIZET cRecords; // Number of records on stack
RECID arecid[MAX_RECORDS]; // Selected record stack ids
BOOL fStackOverFlow; // Address stack overflow
BOOL fBetterAvailable; // Better record available
BOOL fInvZip4; // Invalid ZIP+4
BOOL fInvZip5; // Invalid ZIP5
BOOL fInvCity; // Invalid city/state
BOOL fNoPrimary; // No primary number match
BOOL fSecAvail; // Secondary range available
BOOL fInvSec; // Invalid secondary number
FN_M Z4_MATCH();
virtual FN_M ~Z4_MATCH();
VOID FN_M Clear();
Z4_RESULT FN_M CS(RZ4_PARSE);
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
Z4_RESULT FN_M Z4(RZ4_PARSE);
Z4_RESULT FN_M Z5(RZ4_PARSE);
Z4_RESULT FN_M ZX(RZ4_PARSE);
private:
BOOL FN_M Building();
VOID FN_M ClearRecords(BOOL = TRUE);
VOID FN_M ClearStack();
BOOL FN_M Compare();
Z4_RESULT FN_M Finish();
BOOL FN_M Firm();
BOOL FN_M Other();
BOOL FN_M RR();
BOOL FN_M Select(Z4_REC_CODE);
BOOL FN_M Search(PCSZ);
};
//----------------------------------------------------------------------------
// Class Z4_STANDARDIZE
//----------------------------------------------------------------------------
#define Z4_STANDARDIZE_PARENT CL_OBJECT
class CLASSTYPE Z4_STANDARDIZE : public Z4_STANDARDIZE_PARENT
{
BOOL FN_M Complete();
BOOL FN_M LastLine(RZ4_CS, PCSZ, PCSZ = NULL);
public:
///// Display address
CHAR szAddress[MAX_ADDR+1]; // Complete address
CHAR szAddr1[MAX_ADDR_LINE+1]; // Address line 1
CHAR szAddr2[MAX_ADDR_LINE+1]; // Address line 2
CHAR szLastLine[MAX_ADDR_LINE+1]; // Last line
///// Display pieces
CHAR szCity[MAX_CITY+1]; // City name
Z4_STATE state; // State
CHAR szZip5[MAX_ZIP5+1]; // 5 digit ZIP
CHAR szAddon[MAX_ZIP4+1]; // Addon
CHAR szZip4[MAX_ZIP4+2]; // 9 digit ZIP w/ dash
///// Flags
BOOL fFacilityOther; // Facility code 9 city names in ZIP5
BOOL fNonDeliverable; // Address is non-deliverable
FN_M Z4_STANDARDIZE();
virtual FN_M ~Z4_STANDARDIZE();
static VOID FN_M Addr1Display(PSZ, RZ4_Z4);
static VOID FN_M Addr2Display(PSZ, RZ4_Z4, PCSZ = NULL, PCSZ = NULL, Z4_UNIT = Z4_UNIT_BLANK);
VOID FN_M Clear();
BOOL FN_M CS(RZ4_CX, PCSZ);
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
static VOID FN_M LastLineDisplay(PSZ, RZ4_CS, PCSZ, PCSZ = NULL);
static VOID FN_M PriRangeDisplay(PSZ, RZ4_Z4);
static PSZ FN_M RangeDisplay(PSZ, PCSZ);
static VOID FN_M SecRangeDisplay(PSZ, RZ4_Z4);
BOOL FN_M Z4(RRECID, RZ4_PARSE);
BOOL FN_M Z5(RRECID, PCSZ);
BOOL FN_M ZX(RRECID, PCSZ);
};
//----------------------------------------------------------------------------
// Class Z4_INQ
//----------------------------------------------------------------------------
#define Z4_INQ_PARENT CL_OBJECT
class CLASSTYPE Z4_INQ : public Z4_INQ_PARENT
{
public:
static BOOL fInit;
///// Data files
static Z4_AB_FILE ab_file; // Abbrevation file
static Z4_CS_FILE cs_file; // City/state file
static Z4_CX_FILE cx_file; // City/state cross reference
static Z4_ST_FILE st_file; // State file
static Z4_Z4_FILE z4_file; // ZIP+4 file
static Z4_Z5_FILE z5_file; // ZIP 5 file
static Z4_ZX_FILE zx_file; // ZIP+4 cross reference
///// Work area
static Z4_CS cs; // City/state record
static Z4_CX cx; // City/state cross reference
static Z4_Z4 z4; // ZIP4 record
static Z4_Z5 z5; // ZIP5 record
static Z4_ZX zx; // ZIP4 cross reference record
///// Request and result codes/
Z4_RQ request; // Request
Z4_RESULT result; // Result
PFNZIP4 pfnzip4; // Call back
///// Flags
BOOL fInvZip4; // Invalid ZIP+4
BOOL fInvZip5; // Invalid ZIP5
BOOL fInvCity; // Invalid city/state
BOOL fInvState; // Invalid city/state
BOOL fZip5Changed; // ZIP 5 changed
BOOL fCSChanged; // City/state changed
BOOL fAddrChanged; // Address line changed
BOOL fFacilityOther; // Facility code 9 city names in ZIP5
BOOL fNonDeliverable; // Address is non-deliverable
BOOL fBetterAvailable; // Better record available
BOOL fNoPrimary; // No primary number match
BOOL fSecAvail; // Secondary range available
BOOL fInvSec; // Invalid secondary number
BOOL fStackOverFlow; // Address stack overflow
///// Input address data
CHAR szAddr1[MAX_INPUT_ADDR+1]; // Input address line 1
CHAR szAddr2[MAX_INPUT_ADDR+1]; // Input address line 2
CHAR szCity[MAX_INPUT_CITY+1]; // Input city name
CHAR szState[MAX_INPUT_STATE+1]; // Input state
CHAR szZip[MAX_INPUT_ZIP+1]; // Input ZIP
///// Parsed address data
Z4_MATCH match; // Match class
Z4_PARSE parse; // Parse class
Z4_STANDARDIZE std; // Standardize class
SIZET cSelect; // Selected match item.
FN_M Z4_INQ();
FN_M Z4_INQ(RCZ4_INQ);
virtual FN_M ~Z4_INQ();
VOID FN_M Clear();
static BOOL FN_M Close();
virtual BOOL FN_M Destroy(BOOL = TRUE);
virtual BOOL FN_M Initialize(SHORT = CL_INIT_ALL);
BOOL FN_M Inquiry(Z4_RQ = Z4_RQ_DFT);
static BOOL FN_M Open(FLAG16 = Z4_INQ_ALL);
BOOL FN_M Select(SIZET = 0);
BOOL FN_M Set(PCSZ, PCSZ, PCSZ, PCSZ = NULL, PCSZ = NULL);
static BOOL FN_E Start(FLAG16 = Z4_INQ_ALL);
static BOOL FN_E Terminate();
protected:
VOID FN_M Flags();
};
//----------------------------------------------------------------------------
//------------------------------- End of File --------------------------------
//----------------------------------------------------------------------------
#endif // COMPILE_CPP
#endif // _Z4_H_
